
#include "define.h"
#include "w25qxx.h"
#include "flash.h"

//SPIx 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
uint8_t SPI2_ReadWriteByte(uint8_t TxData)
{
	uint8_t retry=0;
	//当数据寄存器里有数据时，TXE位是0，当数据全部从数据寄存器的发送缓冲区传输到
	//移位寄存器时,TXE位被置1，这时候，可以往数据寄存器里面写入数据。
	//while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
	while(SPI_GetFlagStatus(SPI_Flag_TXE) == RESET)       //d:检查指定的SPI标志位设置与否:发送缓存空标志位
	{
		retry++;
		if(retry>200)return 0;
	}
	//往SPIx数据寄存器写入数据TxData
	//SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个数据
	SPI_SendData(TxData);//d:通过外设SPIx发送一个数据
	retry=0;
	//while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
	while(SPI_GetFlagStatus(SPI_Flag_RXNE) == RESET)     //d:检查指定的SPI标志位设置与否:接受缓存非空标志位
	{
		retry++;
		if(retry>200)return 0;
	}
	//从数据寄存器读取数据
	//return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据
	return SPI_ReceiveData();     //d:返回通过SPIx最近接收的数据

}
void 	delay_us(uint8_t delay_tmp)
{
	for(int i=0;i<delay_tmp;i++)
	{
		asm("nop");
	}
}
//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q128
//容量为16M字节,共有128个Block,4096个Sector

//初始化SPI FLASH的IO口
void W25QXX_Init(void)
{
	GPIO_InitTypeDef	GPIO_InitStructure;                 //d:片选P27设置成输出
    SPI_DeInit();
	GPIO_WriteOutputDataBit(GPIO2,GPIO_Pin_7,Bit_SET);//d:SPI FLASH不选中
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_OUT;
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_7;
	GPIO_InitStructure.GPIO_PTSR=GPIO_PTSR_WEAK;
	GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;
	GPIO_Init(GPIO2,&GPIO_InitStructure);

 	//初始化SPI设置(主机配置为接收发送)
	SPI_InitTypeDef	         SPI_InitStruct;
	RCC_APBPeriphClockCmd(RCC_APBPeriph_SPI,ENABLE);    //外设时钟使能

	SPI_InitStruct.SPI_Mode=SPI_Mode_Master;       //配置为主设备
	SPI_InitStruct.SPI_BaudRatePrescaler=SPI_BaudRatePrescaler_2;  //波特率设置
	SPI_InitStruct.SPI_CPOL=SPI_CPOL_High ;            //空闲状态时，SCK时钟保持高电平
    SPI_InitStruct.SPI_CPHA= SPI_CPHA_2Edge;           //在串行同步时钟的第一个跳变(上升或下降)沿数据被采样
    SPI_InitStruct.SPI_DataSize=SPI_DataSize_8b;	   //设置数据长度
    SPI_InitStruct.SPI_FirstBit=SPI_FirstBit_MSB;      //帧格式选择位：先发送MSB
	SPI_InitStruct.SPI_NSS= SPI_NSS_Soft;              //启用软件从设备管理，内部NSS信号由SPI_CR的SSI位来驱动，NSS引脚可以用作它用。
    SPI_Init(&SPI_InitStruct);                         //SPI初始化

	SPI_NSSInternalSoftwareCmd(ENABLE);
	SPI_NSSOutputCmd(ENABLE);   //使能NSS引脚输出，即使能SPI的片选CS信号  SSOE
	SPI_Cmd(ENABLE);            //SPI使能

	//SPI_Cmd(SPI2, ENABLE); //使能SPI外设
	SPI2_ReadWriteByte(0xff);//启动传输

	//SPI2_SetSpeed(SPI_BaudRatePrescaler_2);//设置为18M时钟,高速模式

	W25QXX_TYPE=W25QXX_ReadID();//读取FLASH ID.
}

// //读取W25QXX的状态寄存器
// //BIT7  6   5   4   3   2   1   0
// //SPR   RV  TB BP2 BP1 BP0 WEL BUSY
// //SPR:默认0,状态寄存器保护位,配合WP使用
// //TB,BP2,BP1,BP0:FLASH区域写保护设置
// //WEL:写使能锁定
// //BUSY:忙标记位(1,忙;0,空闲)
// //默认:0x00
uint8_t W25QXX_ReadSR(void)
{
	uint8_t byte=0;
	W25QXX_CS_0;                            //使能器件
	SPI2_ReadWriteByte(W25X_ReadStatusReg); //发送读取状态寄存器命令
	byte=SPI2_ReadWriteByte(0Xff);          //读取一个字节
	W25QXX_CS_1;                            //取消片选
	return byte;
}
// //写W25QXX状态寄存器
// //只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
// void W25QXX_Write_SR(uint8_t sr)
// {
// 	W25QXX_CS_0;                            //使能器件
// 	SPI2_ReadWriteByte(W25X_WriteStatusReg);//发送写取状态寄存器命令
// 	SPI2_ReadWriteByte(sr);               	//写入一个字节
// 	W25QXX_CS_1;                            //取消片选
// }
// //W25QXX写使能
// //将WEL置位
void W25QXX_Write_Enable(void)
{
	W25QXX_CS_0;                          	//使能器件
    SPI2_ReadWriteByte(W25X_WriteEnable); 	//发送写使能
	W25QXX_CS_1;                           	//取消片选
}
// //W25QXX写禁止
// //将WEL清零
// void W25QXX_Write_Disable(void)
// {
// 	W25QXX_CS_0;                            //使能器件
//     SPI2_ReadWriteByte(W25X_WriteDisable);  //发送写禁止指令
// 	W25QXX_CS_1;                            //取消片选
// }
//读取芯片ID
//返回值如下:
//0XEF13,表示芯片型号为W25Q80
//0XEF14,表示芯片型号为W25Q16
//0XEF15,表示芯片型号为W25Q32
//0XEF16,表示芯片型号为W25Q64
//0XEF17,表示芯片型号为W25Q128
uint16_t W25QXX_ReadID(void)
{
	uint16_t Temp = 0;
	W25QXX_CS_0;
	SPI2_ReadWriteByte(0x90);//发送读取ID命令
	SPI2_ReadWriteByte(0x00);
	SPI2_ReadWriteByte(0x00);
	SPI2_ReadWriteByte(0x00);
	Temp|=SPI2_ReadWriteByte(0xFF)<<8;
	Temp|=SPI2_ReadWriteByte(0xFF);
	W25QXX_CS_1;
	return Temp;
}
//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(uint8_t* pBuffer, uint32_t ReadAddr,uint16_t NumByteToRead)
{
 	uint16_t i;
	W25QXX_CS_0;                            	//使能器件
    SPI2_ReadWriteByte(W25X_ReadData);         	//发送读取命令
    SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>16));  	//发送24bit地址
    SPI2_ReadWriteByte((uint8_t)((ReadAddr)>>8));
    SPI2_ReadWriteByte((uint8_t)ReadAddr);
    for(i=0;i<NumByteToRead;i++)
	{
        pBuffer[i]=SPI2_ReadWriteByte(0XFF);   	//循环读数
    }
	W25QXX_CS_1;
}
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
void W25QXX_Write_Page(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
{
 	uint16_t i;
    W25QXX_Write_Enable();                  	//SET WEL
	W25QXX_CS_0;                            	//使能器件
    SPI2_ReadWriteByte(W25X_PageProgram);      	//发送写页命令
    SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>16)); 	//发送24bit地址
    SPI2_ReadWriteByte((uint8_t)((WriteAddr)>>8));
    SPI2_ReadWriteByte((uint8_t)WriteAddr);
    for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer[i]);//循环写数
	W25QXX_CS_1;                            	//取消片选
	W25QXX_Wait_Busy();					   		//等待写入结束
}
//无检验写SPI FLASH
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
{
	uint16_t pageremain;
	pageremain=256-WriteAddr%256; //单页剩余的字节数
	if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
	while(1)
	{
		W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
		if(NumByteToWrite==pageremain)break;//写入结束了
	 	else //NumByteToWrite>pageremain
		{
			pBuffer+=pageremain;
			WriteAddr+=pageremain;

			NumByteToWrite-=pageremain;			  //减去已经写入了的字节数
			if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
			else pageremain=NumByteToWrite; 	  //不够256个字节了
		}
	}
}
//写SPI FLASH
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大65535)

//uint8_t W25QXX_BUFFER[4096];
#define W25QXX_BUFFER MemBack
void W25QXX_Write(uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
{
	uint32_t secpos;
	uint16_t secoff;
	uint16_t secremain;
 	uint16_t i;
	uint8_t * W25QXX_BUF;
   	W25QXX_BUF=(uint8_t *)W25QXX_BUFFER;
 	secpos=WriteAddr/4096;//扇区地址
	secoff=WriteAddr%4096;//在扇区内的偏移
	secremain=4096-secoff;//扇区剩余空间大小
 	if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
	while(1)
	{
		W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
		for(i=0;i<secremain;i++)//校验数据
		{
			if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除
		}
		if(i<secremain)//需要擦除
		{
			W25QXX_Erase_Sector(secpos);		//擦除这个扇区
			for(i=0;i<secremain;i++)	   		//复制
			{
				W25QXX_BUF[i+secoff]=pBuffer[i];
			}
			W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区

		}
		else
		{
			W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.
		}

		if(NumByteToWrite==secremain)break;//写入结束了
		else//写入未结束
		{
			secpos++;//扇区地址增1
			secoff=0;//偏移位置为0

		   	pBuffer+=secremain;  				//指针偏移
			WriteAddr+=secremain;				//写地址偏移
		   	NumByteToWrite-=secremain;			//字节数递减
			if(NumByteToWrite>4096)secremain=4096;//下一个扇区还是写不完
			else secremain=NumByteToWrite;		//下一个扇区可以写完了
		}
	};
}
//擦除整个芯片
//等待时间超长...
// void W25QXX_Erase_Chip(void)
// {
//     W25QXX_Write_Enable();                 	 	//SET WEL
//     W25QXX_Wait_Busy();
//   	W25QXX_CS_0;                            	//使能器件
//     SPI2_ReadWriteByte(W25X_ChipErase);        	//发送片擦除命令
// 	W25QXX_CS_1;                            	//取消片选
// 	W25QXX_Wait_Busy();   				   		//等待芯片擦除结束
// }
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个山区的最少时间:150ms
void W25QXX_Erase_Sector(uint32_t Dst_Addr)
{
	//监视falsh擦除情况,测试用
 	//printf("fe:%x\r\n",Dst_Addr);
 	//Dst_Addr*=4096;
    W25QXX_Write_Enable();                  	//SET WEL
    W25QXX_Wait_Busy();
  	W25QXX_CS_0;                            	//使能器件
    SPI2_ReadWriteByte(W25X_SectorErase);      	//发送扇区擦除指令
    SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>16));  	//发送24bit地址
    SPI2_ReadWriteByte((uint8_t)((Dst_Addr)>>8));
    SPI2_ReadWriteByte((uint8_t)Dst_Addr);
	W25QXX_CS_1;                            	//取消片选
    W25QXX_Wait_Busy();   				   		//等待擦除完成
}
// //等待空闲
void W25QXX_Wait_Busy(void)
{
	while((W25QXX_ReadSR()&0x01)==0x01);  		// 等待BUSY位清空
}
//进入掉电模式
void W25QXX_PowerDown(void)
{
	#if W25QXX_ENABLE
  	W25QXX_CS_0;                           	 	//使能器件
    SPI2_ReadWriteByte(W25X_PowerDown);        //发送掉电命令
	W25QXX_CS_1;                            	//取消片选
    delay_us(3);                               //等待TPD
	#endif
}
// //唤醒
// void W25QXX_WAKEUP(void)
// {
// 	#if W25QXX_ENABLE
//   	W25QXX_CS_0;                            	//使能器件
//     SPI2_ReadWriteByte(W25X_ReleasePowerDown);	//  send W25X_PowerDown command 0xAB
// 	W25QXX_CS_1;                            	//取消片选
//     delay_us(3);                            	//等待TRES1
// 	#endif
// }
// volatile uint32_t w25qxx_write_addr;
// //---------------------------  UI entry ------------------------------------------//
// W25QXX_Erase_AUD_Data(void)  //清除语音的数据
// {
// 	for(uint32_t i = 0;i<AUD_SIZE/SECTOR_SIZE;i++)
// 	{
// 		W25QXX_Erase_Sector(i*SECTOR_SIZE);
// 	}
// }
// W25QXX_Erase_Press_Data(void)	//清除血压离线数据
// {
// 	for(uint32_t i = AUD_SIZE/SECTOR_SIZE;i<=ALL_SIZE/SECTOR_SIZE;i++)
// 	{
// 		W25QXX_Erase_Sector(i*SECTOR_SIZE);
// 	}
// }
// void User_W25QXX_WriteByte(uint16_t user_num,uint8_t* pBuffer,uint32_t WriteAddr,uint16_t NumByteToWrite)
// {
//     w25qxx_write_addr = user_num*SECTOR_SIZE*USER_SECTOR_NUM+WriteAddr;
// 	W25QXX_Write_NoCheck(pBuffer,w25qxx_write_addr+AUD_SIZE,NumByteToWrite);

// }
// //获取flash里面存放用户数据的数量
// uint16_t Read_W25QXX_num(void)
// {
// 	uint8_t w25qxx_dat = 0;
// 	for(uint16_t i=0;i<USER_MAX_NUM;i++)
// 	{
// 		W25QXX_Read(&w25qxx_dat,i*SECTOR_SIZE*USER_SECTOR_NUM+AUD_SIZE,1);
// 		if(w25qxx_dat != 0xAA)
// 		{
// 			return i;
// 		}
// 	}
// }

// //串口发送对应的
// uint8_t  Send_user_w25qxx_data(uint32_t user_num)
// {
// 	uint8_t  send_dat;
// 	uint16_t frame_tmp = 0 ;
// 	uint32_t read_max_tmp;
// 	uint8_t cs_add = 0;
// 	W25QXX_Read(&frame_tmp,user_num*SECTOR_SIZE*USER_SECTOR_NUM+AUD_SIZE,2);
// 	if(frame_tmp == 0x55AA)
// 	{
// 		uint8_t send_tmp = 0;
// 		uint32_t send_addr = 0;
// 		for(uint32_t i=0;i<=SECTOR_SIZE*USER_SECTOR_NUM;i++)
// 		{
// 			W25QXX_Read(&read_max_tmp,user_num*SECTOR_SIZE*USER_SECTOR_NUM+i+AUD_SIZE,4);
// 			if(read_max_tmp == 0x55AA55AA)
// 			{
// 				read_max_addr = i;
// 				break;
// 			}
// 		}
// 		for(uint32_t i=0;i<read_max_addr+4;i++)
// 		{
// 			W25QXX_Read(&send_dat,(user_num*SECTOR_SIZE*USER_SECTOR_NUM)+i+AUD_SIZE,1);
// 			Send_Uart_Data(UART1,&send_dat,1);
// 			cs_add= (uint8_t)(send_dat+cs_add);
// 		}
// 		Send_Uart_Data(UART1,&cs_add,1);    //发送1字节校验码
// 		ProgramState = Sleep_State;         //发送完数据后进入睡眠
// 		NextState=0x00;
// 		Pulse_CounterTimer=0;
// 		SleepTimeCnt=0;
// 		DelayCnt=0;
// 	}
// 	else
// 	{
// 		return 0;
// 	}
// 	return 1;
// }

// const uint8_t Pressure_frame_header[6] = {0xAA,0x55,0x53,0x44,0x55,0xAA};	//血压气压和ADC值开始帧头
// const uint8_t pulse_frame_header[6] = {0xAA,0x55,0x53,0x44,0xAA,0x55};	    //脉搏数据开始帧头
// const uint8_t result_frame_header[6] = {0xAA,0x55,0x44,0x53,0x55,0xAA};	    //结果数据开始帧头
// const uint8_t frame_end[4] = {0xAA,0x55,0xAA,0x55};	    					//帧尾


// void w25qxxProgram(void)
// {
// 	#if W25QXX_ENABLE
// 	uint16_t data_tmp = 0;
// 	Uart_RecevieHandle();                               //如果串口接收到0XAA 0X55就开始发送串口数据

// 	if(ProgramState == GetZero_State)
// 	{
// 		user_cur_num = Read_W25QXX_num();	   			//获取需要设置的用户编号  0~300个用户
// 		w25qxx_AddNum = 0;
// 		if(user_cur_num>=USER_MAX_NUM)         			//如果用户超出显示USER_MAX_NUM
// 		{
// 			Flag1 |= 0x01<<Flag1_w25qxxUserOver;
// 			ProgramState=DispResult_State;
// 			PWM_SetDutyCycle(PWM0,5*0);
// 			PWM_SetDutyCycle(PWM1,24*0);
// 			NextState=0x00;
// 			Pulse_CounterTimer=0;
// 			SleepTimeCnt=0;
// 			DelayCnt=0;
// 		}
// 	}
// 	else if(ProgramState == Measuring_State)
// 	{
// 		if(NextState == 0)
// 		{
// 			User_W25QXX_WriteByte(user_cur_num,Pressure_frame_header,w25qxx_AddNum,sizeof(Pressure_frame_header));     // 6字节  起始码
// 			w25qxx_AddNum = w25qxx_AddNum+sizeof(Pressure_frame_header);

// 		}
// 		if((Flag1&(0x01<<Flag1_ADCOk)) != 0)
// 		{
// 			Flag1 &= ~(0x01<<Flag1_ADCOk);//ADC转换完成标志清零
// 			data_tmp = H_L_change(BP_cur_adcData);                                         //高字节在前
// 			User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);                 //2字节 实时ADC值
// 			w25qxx_AddNum = w25qxx_AddNum+2;
// 			data_tmp = H_L_change(CurrentPressure_X10);
// 			User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);				   //2字节 实时ADC值
// 			w25qxx_AddNum = w25qxx_AddNum+2;
// 			if(w25qxx_AddNum >= (SECTOR_SIZE*USER_SECTOR_NUM - 10))                       //如果单个用户超出字节范围，发送结束码后关机
// 			{
// 				User_W25QXX_WriteByte(user_cur_num,frame_end,w25qxx_AddNum,sizeof(frame_end));//如果测量到一半关机，需要保存结束码
// 				LCD_Dis_Er8();
// 				Delay100us(20000);
// 				ProgramState =Sleep_State;
// 			}

// 		}

// 	}
// 	else if(ProgramState == DispResult_State)
// 	{
// 		if(NextState == 1)
// 		{
// 			NextState =2;
// 			if( (Flag1 & (0x01<<Flag1_Measure_Pass)) || (Flag1 & (0x01<<Flag1_Error_Null)) )
// 			{
// 				;
// 			}
// 			else
// 			{
// 				if(NextState == 2)
// 				{
// 					NextState = 3;
// 					User_W25QXX_WriteByte(user_cur_num,frame_end,w25qxx_AddNum,sizeof(frame_end));//如果测量到一半关机，需要保存结束码
// 					w25qxx_AddNum = w25qxx_AddNum+sizeof(frame_end);
// 				}
// 				return;
// 			}


// 			User_W25QXX_WriteByte(user_cur_num,pulse_frame_header,w25qxx_AddNum,6);			//6字节  发送脉搏起始码
// 			w25qxx_AddNum = w25qxx_AddNum+6;
// 			for(uint8_t i=0;i<WaveNumber;i++)
// 			{
// 				data_tmp =  H_L_change(Pulse_Static_Pressure[i]);
// 				User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);				//2字节的静态气压
// 				w25qxx_AddNum = w25qxx_AddNum+2;

// 				data_tmp =  H_L_change(Pulse_Area_Wave[i]);
// 				User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);				//2字节的脉搏面积
// 				w25qxx_AddNum = w25qxx_AddNum+2;

// 				data_tmp =  H_L_change(Area_Wave_Avg_Array[i]);
// 				User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);				//2字节的脉搏面积
// 				w25qxx_AddNum = w25qxx_AddNum+2;

// 				data_tmp =  H_L_change(Amp_Wave_Array[i]);
// 				User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);				//2字节的脉搏振幅
// 				w25qxx_AddNum = w25qxx_AddNum+2;

// 				data_tmp =  H_L_change(Pulse_Cycle[i]);
// 				User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);				//2字节的脉搏周期
// 				w25qxx_AddNum = w25qxx_AddNum+2;
// 			}
// 			User_W25QXX_WriteByte(user_cur_num,result_frame_header,w25qxx_AddNum,6);		//6字节 血压数据起始码
// 			w25qxx_AddNum = w25qxx_AddNum+6;

// 			//data_tmp = decimal_bcd_code(ADC_Cal_Code_Seg1);                                 //转成BCD码
// 			data_tmp = H_L_change(ADC_Cal_Code_Seg1);                                                //高低字节互换
// 			User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);					//2字节标定码值
// 			w25qxx_AddNum = w25qxx_AddNum+2;

// 			//data_tmp = decimal_bcd_code(ADC_Cal_pressure_Seg1);
// 			data_tmp = H_L_change(ADC_Cal_pressure_Seg1);
// 			User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);					//2字节标定气压*10
// 			w25qxx_AddNum = w25qxx_AddNum+2;

// 			data_tmp = decimal_bcd_code(SBP_Data_HEX);
// 			data_tmp = H_L_change(data_tmp);
// 			User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);					//2字节上压
// 			w25qxx_AddNum = w25qxx_AddNum+2;

// 			data_tmp = decimal_bcd_code(DBP_Data_HEX);
// 			data_tmp = H_L_change(data_tmp);
// 		 	User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);					//2字节下压
// 			w25qxx_AddNum = w25qxx_AddNum+2;

// 			data_tmp = decimal_bcd_code(Pulse_Data_HEX);
// 			data_tmp = H_L_change(data_tmp);
// 			User_W25QXX_WriteByte(user_cur_num,&data_tmp,w25qxx_AddNum,2);					//2字节心率
// 			w25qxx_AddNum = w25qxx_AddNum+2;

// 			uint8_t RTC_HourFormat;
// 			RTC_DateTypeDef RTC_DateStructure;
// 			RTC_TimeTypeDef	RTC_TimeStructure;

// 			RTC_GetDate(&RTC_DateStructure);//获取年月日
// 			RTC_GetTime(&RTC_TimeStructure);//获取时分秒

// 			User_W25QXX_WriteByte(user_cur_num,&RTC_DateStructure.RTC_Month,w25qxx_AddNum,1);	//1字节 月份
// 			w25qxx_AddNum = w25qxx_AddNum+1;
// 			User_W25QXX_WriteByte(user_cur_num,&RTC_DateStructure.RTC_Date,w25qxx_AddNum,1);	//1字节 日期
// 			w25qxx_AddNum = w25qxx_AddNum+1;
// 			User_W25QXX_WriteByte(user_cur_num,&RTC_TimeStructure.RTC_Hours,w25qxx_AddNum,1);	//1字节 小时
// 			w25qxx_AddNum = w25qxx_AddNum+1;
// 			User_W25QXX_WriteByte(user_cur_num,&RTC_TimeStructure.RTC_Minutes,w25qxx_AddNum,1);	//1字节 分钟
// 			w25qxx_AddNum = w25qxx_AddNum+1;

// 			User_W25QXX_WriteByte(user_cur_num,frame_end,w25qxx_AddNum,sizeof(frame_end));		//4字节 数据结束码
// 			w25qxx_AddNum = w25qxx_AddNum+sizeof(frame_end);


// 		}
// 		if(NextState == 2)
// 		{
// 			NextState = 3;
// 		}
// 	}
// 	if(measuring_poweroff_flag == 1)
// 	{
// 		measuring_poweroff_flag = 0;
// 		User_W25QXX_WriteByte(user_cur_num,frame_end,w25qxx_AddNum,sizeof(frame_end));//如果测量到一半关机，需要保存结束码
// 		w25qxx_AddNum = w25qxx_AddNum+sizeof(frame_end);
// 	}
// 	#endif

// }























